#ifndef ENEMYS_HH
#define ENEMYS_HH

#include "Aenemy.hh"
#include "Ahero.hh"
#include "randomFunc.hh"
#include "IO.hh"
#include "enemy_setting.hh"

namespace enemys
{


    //Cultist Brawler邪教徒格斗者
    class Cultist_Brawler : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Cultist_Brawler(std::string enemy_name, unsigned position_inteam);
        Cultist_Brawler(const Cultist_Brawler& other);
        Cultist_Brawler& operator=(const Cultist_Brawler& other);
        ~Cultist_Brawler() override = default;
        

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Cultist Acolyte邪教徒侍僧
    class Cultist_Acolyte : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Cultist_Acolyte(std::string enemy_name, unsigned position_inteam);
        Cultist_Acolyte(const Cultist_Acolyte& other);
        Cultist_Acolyte& operator=(const Cultist_Acolyte& other);
        ~Cultist_Acolyte() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Madman疯子
    class Madman : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Madman(std::string enemy_name, unsigned position_inteam);
        Madman(const Madman& other);
        Madman& operator=(const Madman& other);
        ~Madman() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Bone Soldier骷髅士兵
    class Bone_Soldier : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Bone_Soldier(std::string enemy_name, unsigned position_inteam);
        Bone_Soldier(const Bone_Soldier& other);
        Bone_Soldier& operator=(const Bone_Soldier& other);
        ~Bone_Soldier() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Bone Courtier骨廷
    class Bone_Courtier : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Bone_Courtier(std::string enemy_name, unsigned position_inteam);
        Bone_Courtier(const Bone_Courtier& other);
        Bone_Courtier& operator=(const Bone_Courtier& other);
        ~Bone_Courtier() override = default;


        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Bone Arbalist骨劲弩
    class Bone_Arbalist : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Bone_Arbalist(std::string enemy_name, unsigned position_inteam);
        Bone_Arbalist(const Bone_Arbalist& other);
        Bone_Arbalist& operator=(const Bone_Arbalist& other);
        ~Bone_Arbalist() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Bone Defender骨骼防御者
    class Bone_Defender : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Bone_Defender(std::string enemy_name, unsigned position_inteam);
        Bone_Defender(const Bone_Defender& other);
        Bone_Defender& operator=(const Bone_Defender& other);
        ~Bone_Defender() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Swine Chopper猪斩拌机
    class Swine_Chopper : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Swine_Chopper(std::string enemy_name, unsigned position_inteam);
        Swine_Chopper(const Swine_Chopper& other);
        Swine_Chopper& operator=(const Swine_Chopper& other);
        ~Swine_Chopper() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Swine Slasher杀猪者
    class Swine_Slasher : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Swine_Slasher(std::string enemy_name, unsigned position_inteam);
        Swine_Slasher(const Swine_Slasher& other);
        Swine_Slasher& operator=(const Swine_Slasher& other);
        ~Swine_Slasher() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Swine Drummer猪鼓手
    class Swine_Drummer : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Swine_Drummer(std::string enemy_name, unsigned position_inteam);
        Swine_Drummer(const Swine_Drummer& other);
        Swine_Drummer& operator=(const Swine_Drummer& other);
        ~Swine_Drummer() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Carrion Eater腐肉吞噬者
    class Carrion_Eater : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Carrion_Eater(std::string enemy_name, unsigned position_inteam);
        Carrion_Eater(const Carrion_Eater& other);
        Carrion_Eater& operator=(const Carrion_Eater& other);
        ~Carrion_Eater() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Brigand Cutthroat强盗割喉
    class Brigand_Cutthroat : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Brigand_Cutthroat(std::string enemy_name, unsigned position_inteam);
        Brigand_Cutthroat(const Brigand_Cutthroat& other);
        Brigand_Cutthroat& operator=(const Brigand_Cutthroat& other);
        ~Brigand_Cutthroat() override = default;
        

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Brigand Fusilier土匪燧发枪手
    class Brigand_Fusilier : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Brigand_Fusilier(std::string enemy_name, unsigned position_inteam);
        Brigand_Fusilier(const Brigand_Fusilier& other);
        Brigand_Fusilier& operator=(const Brigand_Fusilier& other);
        ~Brigand_Fusilier() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Brigand Bloodletter强盗血信
    class Brigand_Bloodletter : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Brigand_Bloodletter(std::string enemy_name, unsigned position_inteam);
        Brigand_Bloodletter(const Brigand_Bloodletter& other);
        Brigand_Bloodletter& operator=(const Brigand_Bloodletter& other);
        ~Brigand_Bloodletter() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Pelagic Grouper远洋石斑鱼
    class Pelagic_Grouper : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Pelagic_Grouper(std::string enemy_name, unsigned position_inteam);
        Pelagic_Grouper(const Pelagic_Grouper& other);
        Pelagic_Grouper& operator=(const Pelagic_Grouper& other);
        ~Pelagic_Grouper() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Pelagic Shaman远洋萨满
    class Pelagic_Shaman : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Pelagic_Shaman(std::string enemy_name, unsigned position_inteam);
        Pelagic_Shaman(const Pelagic_Shaman& other);
        Pelagic_Shaman& operator=(const Pelagic_Shaman& other);
        ~Pelagic_Shaman() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;

    };

    //Pelagic Guardian远洋守护者
    class Pelagic_Guardian : public Aenemy
    {
    private:
        unsigned skill1_min_attack;
        unsigned skill1_max_attack;
        unsigned skill1_crit;
        unsigned skill2_min_attack;
        unsigned skill2_max_attack;
        unsigned skill2_crit;

    public:
        Pelagic_Guardian(std::string enemy_name, unsigned position_inteam);
        Pelagic_Guardian(const Pelagic_Guardian& other);
        Pelagic_Guardian& operator=(const Pelagic_Guardian& other);
        ~Pelagic_Guardian() override = default;

        void skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
        void skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) override;
    
    };
};

#endif
